/**
 * 聊天API
 * 使用观察者模式处理聊天相关事件
 */

import apiManager from './ApiManager.js'
import { API_PATHS } from './config.js'
import { Buffer } from 'buffer'

class ChatAPI {
  constructor() {
    // 观察者列表
    this.observers = new Map()
    
    // 流式请求任务映射
    this.streamTasks = new Map()
  }
  
  /**
   * 添加观察者
   * @param {string} event 事件名称
   * @param {Function} callback 回调函数
   */
  addObserver(event, callback) {
    if (!this.observers.has(event)) {
      this.observers.set(event, new Set())
    }
    this.observers.get(event).add(callback)
  }
  
  /**
   * 移除观察者
   * @param {string} event 事件名称
   * @param {Function} callback 回调函数
   */
  removeObserver(event, callback) {
    if (this.observers.has(event)) {
      this.observers.get(event).delete(callback)
      if (this.observers.get(event).size === 0) {
        this.observers.delete(event)
      }
      }
  }
  
  /**
   * 通知观察者
   * @param {string} event 事件名称
   * @param {any} data 数据
   */
  notifyObservers(event, data) {
    if (this.observers.has(event)) {
      this.observers.get(event).forEach(callback => {
        try {
          callback(data)
        } catch (error) {
          console.error(`观察者处理${event}事件时出错:`, error)
        }
      })
    }
  }
  
  /**
   * 获取聊天历史记录
   * @param {String} memoryId 聊天记录ID（用户ID）
   */
  getChatHistory(memoryId) {
    console.log('debug', '获取聊天历史记录请求', { memoryId })
    return apiManager.get(API_PATHS.GET_CHAT_HISTORY, { memoryId }, {
      showLoading: false
    })
  }
  
  /**
   * 发送聊天消息（流式输出版本）
   * @param {Object} chatForm 聊天表单数据
   * @param {Function} onMessageReceived 接收流式消息的回调函数
   */
  sendChatMessageStreaming(chatForm, onMessageReceived) {
    return new Promise((resolve, reject) => {
      try {
        // 创建请求任务
        const token = uni.getStorageSync('asurada_user_token')
        const headers = {
          'Content-Type': 'application/json',
          'Accept': 'text/event-stream'
        }
        
        if (token) {
          headers['Authorization'] = `Bearer ${token}`
        }
        
        const requestId = `stream_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
        let fullContent = ''
        
        const requestTask = uni.request({
          url: apiManager.getConfig().baseURL + API_PATHS.STREAM_CHAT,
          method: 'POST',
          header: headers,
          data: chatForm,
          enableChunked: true, // 启用分块传输
          success: (res) => {
            console.log('>>> [STREAM] Final received data (full body):', res.data);
            this.streamTasks.delete(requestId)
            // 通知观察者流式传输完成并解析Promise
            this.notifyObservers('streamComplete', { requestId, content: fullContent })
            resolve(fullContent)
          },
          fail: (error) => {
            console.error('>>> [STREAM] Request failed (fail callback).');
            console.error('>>> [STREAM] Error object:', error);
            this.streamTasks.delete(requestId)
            reject(new Error('流式传输失败'))
          }
        })
        
        // 保存请求任务
        this.streamTasks.set(requestId, requestTask)
        
        let responseMsgBuffer = ''
        
        // 监听数据块接收事件（小程序特有）
        if (requestTask && requestTask.onChunkReceived) {
          requestTask.onChunkReceived((res) => {

            // 安全校验，防止因res.chunk不存在而崩溃
            if (res && res.data) {
              const dataText = Buffer.from(res.data).toString('utf-8')
              console.log('>>> 收到的数据块内容:', dataText);
              responseMsgBuffer += dataText
              
              // 按照SSE协议分割数据块（以双换行符分隔）
              const msgs = responseMsgBuffer.split('\n\n')
              responseMsgBuffer = msgs.pop() || '' // 保留未完整的消息在缓冲区
              
              // 处理完整的消息
              msgs.forEach(m => {
                if (m.startsWith('data:')) {
                  const text = m.slice(5).trim() // 移除 "data:" 前缀
                  
                  if (text) {
                    // 累积内容
                    fullContent += text
                    
                    // 调用回调函数处理数据
                    if (typeof onMessageReceived === 'function') {
                      onMessageReceived(text, fullContent)
                    }
                    
                    // 通知观察者接收到新数据
                    this.notifyObservers('streamData', { requestId, chunk: text, content: fullContent })
                  }
                }
              })
            } else {
              console.warn('>>> [STREAM] Received an event on onChunkReceived, but it had no res.chunk. Event object:', res);
            }
          })
        }
        
      } catch (error) {
        console.error('流式传输初始化失败:', error)
        reject(new Error('流式传输初始化失败'))
      }
    })
  }
  
  /**
   * 取消流式请求
   * @param {string} requestId 请求ID
   */
  cancelStreamRequest(requestId) {
    if (this.streamTasks.has(requestId)) {
      const requestTask = this.streamTasks.get(requestId)
      requestTask.abort()
      this.streamTasks.delete(requestId)
      console.log(`已取消流式请求: ${requestId}`)
    }
  }
  
  /**
   * 取消所有流式请求
   */
  cancelAllStreamRequests() {
    this.streamTasks.forEach((requestTask, requestId) => {
      requestTask.abort()
      console.log(`已取消流式请求: ${requestId}`)
    })
    this.streamTasks.clear()
  }
}

// 导出单例实例
const chatAPI = new ChatAPI()
export default chatAPI